package collection

import (
	"iter"
)

// MapAs 明确KV类型的Map数据结构

type MapAs[K comparable, V any] map[K]V

// NewMapAs 创建一个NewMapAs
// - 推介字面量创建MapAs
// - collections.MapAs{"name": "value"} 创建
func NewMapAs[K comparable, V any](size ...uint) MapAs[K, V] {
	if len(size) > 0 && size[0] > 0 {
		return make(MapAs[K, V], size[0])
	}
	return MapAs[K, V]{}
}

// Set 添加键值，单层替换方式
func (m MapAs[K, V]) Set(key K, val V) MapAs[K, V] {
	m[key] = val
	return m
}

// Merge 合并map到*MapShard, 单层替换方式合并
func (m MapAs[K, V]) Merge(maps map[K]V) MapAs[K, V] {
	if len(maps) == 0 {
		return m
	}
	for key, val := range maps {
		m[key] = val
	}
	return m
}

// Has 判断是否存在key
func (m MapAs[K, V]) Has(key K) bool {
	if _, ok := m[key]; ok {
		return true
	}
	return false
}

// GetE 取得map[K]V数据集的元素值
func (m MapAs[K, V]) GetE(key K) (val V, ok bool) {
	if v, ok := m[key]; ok {
		return v, true
	}
	return
}

// GetD 取得map[K]V数据集的元素值，不存在时返回默认值
func (m MapAs[K, V]) GetD(key K, defaultVal V) (val V) {
	if m == nil {
		return defaultVal
	}
	if v, ok := m[key]; ok {
		return v
	}
	return defaultVal
}

// Delete 删除map[K]V数据集的元素值
func (m MapAs[K, V]) Delete(key K) MapAs[K, V] {
	delete(m, key)
	return m
}

// Size 获取数据集大小
func (m MapAs[K, V]) Size() (size int) {
	return len(m)
}

// Clear 清空所有数据
func (m MapAs[K, V]) Clear() {
	for k := range m {
		delete(m, k)
	}
}

// Collects 取得map[k]v数据集的浅克隆副本  map[K]V
func (m MapAs[K, V]) Collects() (data map[K]V) {
	data = make(map[K]V, len(m))
	if len(m) == 0 {
		return data
	}
	for key, val := range m {
		data[key] = val
	}
	return data
}

// Keys 取得map键 数据集的键名副本 []K
func (m MapAs[K, V]) Keys() (data []K) {
	data = make([]K, 0, len(m))
	for key := range m {
		data = append(data, key)
	}
	return data
}

// Values 取得map值 数据集的浅克隆副本 []V
func (m MapAs[K, V]) Values() (data []V) {
	data = make([]V, 0, len(m))
	for _, val := range m {
		data = append(data, val)
	}
	return data
}

// Iter mak[K]V 元素迭代器
//   - for k,v:=range s.Iter(){}
//   - 注意：迭代顺序不固定, 依据Shard分片+Map[K]V顺序进行迭代
func (m MapAs[K, V]) Iter() iter.Seq2[K, V] {
	return func(yield func(key K, val V) bool) {
		for k, v := range m {
			if !yield(k, v) {
				return
			}
		}
	}
}

// IterKeys map[K]V key迭代器
//   - for key:=range s.IterKeys(){}
func (m MapAs[K, V]) IterKeys() iter.Seq[K] {
	return func(yield func(key K) bool) {
		for k := range m {
			if !yield(k) {
				return
			}
		}
	}
}

// IterValues map[K]V value 迭代器
//   - for val:=range s.IterValues(){}
func (m MapAs[K, V]) IterValues() iter.Seq[V] {
	return func(yield func(val V) bool) {
		for _, v := range m {
			if !yield(v) {
				return
			}
		}
	}
}
